\subsection{Types and Expressions}
	Object types and expressions in CLUBs, and the type checking of these, are straight forward. There are six main kinds of expressions:
	\begin{itemize}
		\item Literals
		\item Identifiers
		\item Unary expressions
		\item Binary expressions
		\item Call expressions
		\item Parenthesis expressions
	\end{itemize}
	
	\subsubsection{Literals}
		The following object types can be expressed as literals:
		\begin{itemize}
			\item Boolean - \textit{true} or \textit{false}.
			\item String - surrounded by quotation marks, ex. \textit{"foo"}.
			\item Integer - ex. \textit{42}.
		\end{itemize}
	
	\subsubsection{Identifiers}
		Identifiers in CLUBs are references to CLUBs objects. These objects can have any of the types specified below.
		It also contains a number of subidentifers, which describe the path to the referenced object.
		
		\begin{itemize}
			\item Simple object types
			\begin{itemize}
				\item Boolean
				\item String
				\item Integer
			\end{itemize}
			\item Complex object types
			\begin{itemize}
				\item Board
				\item Cell
				\item Piece
				\item Player
				\item Round
				\item Turn
				\item Action
			\end{itemize}
		\end{itemize}
		
		After the AST is built, an identification table has been built containing the scopes and names of all declared variables, linking them to an object in memory. The AST is then traversed, looking for identifiers. When an identifier is encountered, we look it up in the identification table and decorate the identifier with the type and location in memory. If the identifier can't be found in the identification table, we report a contextual error.
	
	\subsubsection{Unary expressions}
		$Unary expressions$ consist of an operator and a sub-expression. There are only two operators than can be used in a unary expression, namely $not$ and "$-$".
		When encountering a unary expression during contextual analysis, we check if the operator is $not$ and the sub-expression is a Boolean, or if the operator is "$-$" and the sub-expression is an integer. If one of these two cases holds, the expression is valid. Otherwise, there is an error in the expression.
	
	\subsubsection{Binary expressions}
		$Binary expressions$ are a lot like unary expressions, but instead of having one sub-expression we now have two. The only operator that is not allowed in a binary expression is $not$.
		When encountering a binary expression the first thing we do is making sure the operator is not $not$. We then traverse both expressions to find their types and check if the operator is valid for these two types. Otherwise, a contextual error is reported.
		
	\subsubsection{Call expressions}
		$Call expressions$ consist of an identifier and a list of expressions.
		When encountering a call expression, we first check that the call identifier points to an action object. If not, it can't be called, and the expression is invalid. Then we check that the expressions match the types of the parameters required by the action.
		
	\subsubsection{Parenthesis expressions}
		$Parenthesis expressions$ simply consist of another expression. It is purely a way of nesting expressions, making possible expressions like $x * (y - z)$.
		When encountering a parenthesis expression, we simply traverse the sub-expression and perform the usual contextual analysis on it.